import warnings
%matplotlib inline
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from xgboost import XGBRFRegressor
warnings.filterwarnings ( 'ignore' )
from sklearn.pipeline import Pipeline
pd.set_option ( "display.max_columns" , None )
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import QuantileTransformer
from sklearn.linear_model import LinearRegression, Lasso, Ridge 
from sklearn.model_selection import GridSearchCV, train_test_split
from sklearn.tree import DecisionTreeRegressor, ExtraTreeRegressor
from sklearn.ensemble import AdaBoostRegressor, GradientBoostingRegressor, RandomForestRegressor 
from sklearn.preprocessing import LabelEncoder, MinMaxScaler, Normalizer, StandardScaler , OneHotEncoder
from sklearn.metrics import r2_score, mean_absolute_percentage_error, mean_absolute_error, mean_squared_error

DF = pd.read_csv ( "LAPTOP_DATA.csv" )

DF

DF_Stats_Numeric = DF.describe ( )
DF_Stats_Numeric

DF_Stats_Non_Numeric = DF.describe ( exclude = np.number )
DF_Stats_Non_Numeric

DF.info ( )

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1303 entries, 0 to 1302
Data columns (total 12 columns):
 #   Column            Non-Null Count  Dtype  
---  ------            --------------  -----  
 0   Unnamed: 0        1303 non-null   int64  
 1   Company           1303 non-null   object 
 2   TypeName          1303 non-null   object 
 3   Inches            1303 non-null   float64
 4   ScreenResolution  1303 non-null   object 
 5   Cpu               1303 non-null   object 
 6   Ram               1303 non-null   object 
 7   Memory            1303 non-null   object 
 8   Gpu               1303 non-null   object 
 9   OpSys             1303 non-null   object 
 10  Weight            1303 non-null   object 
 11  Price             1303 non-null   float64
dtypes: float64(2), int64(1), object(9)
memory usage: 122.3+ KB

DF.drop ( columns = [ 'Unnamed: 0' ] , inplace = True )
DF

DF [ 'TouchScreen' ] = DF.ScreenResolution.apply ( lambda x : 1 if 'Touchscreen' in x else 0 )
DF [ 'HD_4K' ] = DF.ScreenResolution.apply ( lambda x : 1 if '4K' in x or 'HD' in x or 'HD+' in x else 0 )
DF [ 'CPU_Types' ] = DF.Cpu.apply ( lambda x : 'Samsung' if 'Samsung' in x else ( 'Intel' if 'Intel' in x else ( 'AMD' if 'AMD' in x else 'Intel' ) ) )
DF [ 'Memory_Types' ] = DF.Memory.apply ( lambda x : 'Flash Storage' if 'Flash Storage' in x else ( 'HDD' if 'HDD' in x else ( 'SSD' ) ) )
DF [ 'GPU_Types' ] = DF.Gpu.apply ( lambda x : 'AMD' if 'AMD' in x else ( 'Nvidia' if 'Nvidia' in x else ( 'Intel' ) ) )
DF [ 'CPU_Frequency' ] = DF.Cpu.str.extract (  r'(\d+GHz)' , expand = True )[0].str.replace ( 'GHz' , '' ).astype ( 'int64' )

DF_Original = DF
DF = DF_Original.iloc [ : , [ 0 , 1 , 2 , 5 , 8 , 9 , 10 , 11 , 12 , 13 , 14] ]
Pixels = DF_Original.ScreenResolution.str.extract ( r'(\d+x\d+)', expand = True  )[0].str.replace ( 'x' , ' ' ).tolist()
Pixels = list( map( lambda x : [ int ( x [ 0 ] ), int( x [ 1 ] ) ], [ i.split ( ) for i in Pixels ] ) )
DF [ 'Length' ] = [ x [ 0 ] for x in Pixels ]
DF [ 'Width' ] = [ x [ 1 ] for x in Pixels ]
DF [ 'PPI' ] = np.sqrt ( DF.Length ** 2 + DF.Width ** 2 ) / DF.Inches

sns.set ( style = "whitegrid" )
for i in DF.drop ( columns = [ 'Price' , 'Weight' , 'CPU_Types' , 'Memory_Types' ]  ) :
    plt.figure ( figsize = ( 20 , 10 ) )
    sns.lineplot ( x = DF [ i ].sort_values ( ) , y = DF.Price , color = '#ADAABF' , markers = '*'  )
    plt.show()

sns.set ( style = "whitegrid" )

plt.figure ( figsize = ( 20 , 10 ) )

sns.barplot ( y = DF.Inches , x = DF[ 'OpSys' ] , palette = 'twilight' )

<Axes: xlabel='OpSys', ylabel='Inches'>

plt.figure ( figsize = ( 20 , 10 ) )
sns.histplot ( data = DF_Original , x = DF_Original.Price , kde = True , hue = 'TouchScreen' , palette = [ '#AA4465', '#2C1320' ] , bins = 60 );

plt.figure ( figsize = ( 20 , 10 ) )
sns.histplot ( data = DF_Original , x = DF_Original.Ram , kde = True , hue =  'HD_4K' , palette = [ '#0A014F', '#CD9FCC' ] );

Data = DF.groupby ( by = ['TypeName']  ).sum ( ).reset_index ( ).loc [ : , ['TouchScreen', 'TypeName'] ]
Colors = [ '#8B85C1' , '#D3FCD5' , '#A8DCD9' , '#A2A3BB' , '#E2A3C7'  , '#815E5B' ,  '#7A6F9B' ]
plt.figure ( figsize = ( 20 , 10 ) )
plt.pie ( x = Data.TouchScreen , autopct = '%1.1f%%', colors = Colors , explode = [ 0 , 0 , 0 , 0.1 , 0.1 , 0.2 ] , labels = list(Data.TypeName.unique ( ))) ;
plt.title ( "The Laptops Types that provide Touch Screen Feature" );

plt.figure ( figsize = ( 20 , 10 ) )
sns.barplot ( x = 'Company' , y = 'Inches' , hue = 'CPU_Types' , data = DF_Original , palette = 'GnBu' )
plt.legend ( loc = 'upper right' , fontsize = 'large' )
plt.show ( )

DF_Original.select_dtypes ( np.number ).plot ( kind = 'box' , subplots = True , layout = ( 3 , 3 ) , figsize = ( 20 , 15 ) , sharex = True , sharey = True );

Mean = DF.Price.mean ( )
Std_Dev = DF.Price.std ( )
Threshold = 3
Lower_Limit = Mean - Threshold * Std_Dev
Upper_Limit = Mean + Threshold * Std_Dev
DF [ 'Price' ] = DF [ 'Price' ].apply ( lambda x : Lower_Limit if x < Lower_Limit else ( Upper_Limit if x > Upper_Limit else x ) )

DF['Price']  = pd.DataFrame ( np.log1p ( DF [ [ 'Price' ] ] ) )
DF.Ram = DF.Ram.str.replace ( 'GB' , '' ).astype ( 'int64' )
DF.Weight = DF.Weight.str.replace ( 'kg' , '' ).astype ( 'float64' )

DF['Weight']  = pd.DataFrame ( np.log1p ( DF [ [ 'Weight' ] ] ) )
DF['PPI']  = pd.DataFrame ( np.log1p  ( DF [ [ 'PPI' ] ] ) )

plt.figure ( figsize = ( 15 , 5 ) )
DF.Price.hist ( bins = 100 , color = '#330036' );
plt.xlabel ( "Price of Laptops" )
plt.title ( "Histogram of Laptop Prices" );

print ( 'Nilai-nilai kosong dalam Data Set adalah sebagai berikut: \n' )
DF.isnull ( ).sum ( ) [ DF.isnull ( ).sum ( ) > 0 ]

Nilai-nilai kosong dalam Data Set adalah sebagai berikut:

Series([], dtype: int64)

DF.select_dtypes ( 'object' )

Categorical_Columns = DF.select_dtypes ( 'object' ).columns.to_list ( )
Categorical_Columns

['Company', 'TypeName', 'OpSys', 'CPU_Types', 'Memory_Types']

for i in DF.loc [ : , Categorical_Columns ] :  
    print ( "\n--------------------------------------------------------------------------\n" , "Column => " , i )
    display ( DF [ i ].value_counts ( ) )

--------------------------------------------------------------------------
 Column =>  Company

Company
Dell         297
Lenovo       297
HP           274
Asus         158
Acer         103
MSI           54
Toshiba       48
Apple         21
Samsung        9
Mediacom       7
Razer          7
Microsoft      6
Vero           4
Xiaomi         4
Chuwi          3
Fujitsu        3
Google         3
LG             3
Huawei         2
Name: count, dtype: int64

--------------------------------------------------------------------------
 Column =>  TypeName

TypeName
Notebook              727
Gaming                205
Ultrabook             196
2 in 1 Convertible    121
Workstation            29
Netbook                25
Name: count, dtype: int64

--------------------------------------------------------------------------
 Column =>  OpSys

OpSys
Windows 10      1072
No OS             66
Linux             62
Windows 7         45
Chrome OS         27
macOS             13
Mac OS X           8
Windows 10 S       8
Android            2
Name: count, dtype: int64

--------------------------------------------------------------------------
 Column =>  CPU_Types

CPU_Types
Intel      1240
AMD          62
Samsung       1
Name: count, dtype: int64

--------------------------------------------------------------------------
 Column =>  Memory_Types

Memory_Types
SSD              653
HDD              575
Flash Storage     75
Name: count, dtype: int64

numeric_DF = DF.select_dtypes(include=[np.number])

plt.figure(figsize=(20,20))
sns.heatmap(data=numeric_DF.corr(), cmap='twilight', annot=True, fmt='0.4f')
plt.show()

numeric_cols = DF.select_dtypes(include=[np.number]).columns
correlation_matrix = DF[numeric_cols].corr()
correlation_matrix = correlation_matrix.where((correlation_matrix > 0.2) | (correlation_matrix < -0.2), '-')
print(correlation_matrix)

               Inches       Ram    Weight     Price TouchScreen     HD_4K  \
Inches            1.0  0.237993  0.869212         -   -0.361735         -   
Ram          0.237993       1.0  0.320475  0.675133           -   0.35487   
Weight       0.869212  0.320475       1.0         -   -0.327295         -   
Price               -  0.675133         -       1.0           -  0.490754   
TouchScreen -0.361735         - -0.327295         -         1.0         -   
HD_4K               -   0.35487         -  0.490754           -       1.0   
Length              -  0.433121         -  0.548136    0.351066  0.484739   
Width               -  0.424437         -  0.545568     0.35793  0.450274   
PPI         -0.444368  0.318253 -0.397236  0.526693    0.442987  0.491712   

               Length     Width       PPI  
Inches              -         - -0.444368  
Ram          0.433121  0.424437  0.318253  
Weight              -         - -0.397236  
Price        0.548136  0.545568  0.526693  
TouchScreen  0.351066   0.35793  0.442987  
HD_4K        0.484739  0.450274  0.491712  
Length            1.0  0.994219  0.904710  
Width        0.994219       1.0  0.914073  
PPI           0.90471  0.914073  1.000000

Train , Test = train_test_split ( DF , random_state = 42 )
Train_X = Train.drop ( columns = [ 'Price' , 'Inches' , 'Length' , 'Width' , 'HD_4K' ] )
Train_Y = Train.Price
Test_X = Test.drop (  columns = [ 'Price' , 'Inches' , 'Length' , 'Width' , 'HD_4K' ] )
Test_Y = Test.Price
print ( "Ukuran atau dimensi dari data set adalah: \n" )
print ( "Train : {}\n\nTest : {}\n".format ( Train.shape , Test.shape ) )
print ( "Train X : {}\n\nTrain Y : {}\n\nTest X : {}\n\nTest Y : {}\n".format ( Train_X.shape , Train_Y.shape , Test_X.shape , Test_Y.shape ) )

Ukuran atau dimensi dari data set adalah: 

Train : (977, 14)

Test : (326, 14)

Train X : (977, 9)

Train Y : (977,)

Test X : (326, 9)

Test Y : (326,)

Columns = list(Train_X.select_dtypes ( 'object' ).columns)

Columns = list(Train_X.select_dtypes ( 'object' ).columns)
Step1 = ColumnTransformer(transformers=[('col_tnf', OneHotEncoder(drop='first'), Columns)], remainder='passthrough')
Step2 = LinearRegression ( )
Pipeline_LR = Pipeline ( [ ( 'step1' , Step1) , ( 'step2' , Step2 ) ] )
Pipeline_LR.fit ( Train_X , Train_Y )

Pipeline(steps=[('step1',
                 ColumnTransformer(remainder='passthrough',
                                   transformers=[('col_tnf',
                                                  OneHotEncoder(drop='first'),
                                                  ['Company', 'TypeName',
                                                   'OpSys', 'CPU_Types',
                                                   'Memory_Types'])])),
                ('step2', LinearRegression())])

Pipeline(steps=[('step1',
                 ColumnTransformer(remainder='passthrough',
                                   transformers=[('col_tnf',
                                                  OneHotEncoder(drop='first'),
                                                  ['Company', 'TypeName',
                                                   'OpSys', 'CPU_Types',
                                                   'Memory_Types'])])),
                ('step2', LinearRegression())])

ColumnTransformer(remainder='passthrough',
                  transformers=[('col_tnf', OneHotEncoder(drop='first'),
                                 ['Company', 'TypeName', 'OpSys', 'CPU_Types',
                                  'Memory_Types'])])

['Company', 'TypeName', 'OpSys', 'CPU_Types', 'Memory_Types']

OneHotEncoder(drop='first')

['Ram', 'Weight', 'TouchScreen', 'PPI']

passthrough

LinearRegression()

Y_LR = Pipeline_LR.predict ( Test_X )
R2_LR = r2_score ( Test_Y , Y_LR ) * 100
N = Train_X.shape[0] 
P = Train_X.shape[1]
print ( "Nilai R2 atau Koefisien Determinasi adalah: " , R2_LR )
Adjusted_R2_LR = 1 - ( ( 1 - R2_LR ) * ( N - 1 ) / ( N - 1 - P ) )
MSE_LR = mean_squared_error ( Test_Y , Y_LR )
RMSE_LR = np.sqrt ( MSE_LR )
MAPE_LR = mean_absolute_percentage_error ( Test_Y , Y_LR ) * 100
MAE_LR = mean_absolute_error ( Test_Y , Y_LR )
print ( "\nNilai R2 yang Disesuaikan adalah: " , Adjusted_R2_LR )

Nilai R2 atau Koefisien Determinasi adalah:  73.0892658319165

Nilai R2 yang Disesuaikan adalah:  73.76021039498501

LR_PM = { 'Performance Metric' : [ 'R2' , 'Adjusted_R2' , 'MSE' , 'RMSE' , 'MAPE' , 'MAE' ] ,         
           'Values' : [ R2_LR , Adjusted_R2_LR , MSE_LR , RMSE_LR , MAPE_LR , MAE_LR ] }
LR_Performance_Metrics = pd.DataFrame ( LR_PM )
LR_Performance_Metrics

plt.figure ( figsize = ( 20 , 10 ) )
sns.histplot ( ( Y_LR - Test_Y ) , bins = 60 , color = '#261447' )
Y_Train_LR = Pipeline_LR.predict ( Train_X )
plt.figure ( figsize = ( 20 , 10 ) )
sns.histplot ( ( Y_Train_LR - Train_Y ) , bins = 60 , color = '#261447' );

# Kemiringan dari distribusi normal adalah 0
Error_Train = Train_Y - Y_Train_LR 
print ( "Nilai skewness dari data latih adalah: ", np.round ( Error_Train.skew ( ) , 2 ) )
# Kurtosis dari distribusi normal adalah 3
print ( "\nNilai kurtosis dari data latih adalah: ", np.round ( Error_Train.kurt ( ) + 3 , 2 )  )

Nilai skewness dari data latih adalah:  0.17

Nilai kurtosis dari data latih adalah:  3.57

# Kemiringan dari distribusi normal adalah 0
Error_Test = Test_Y - Y_LR 
print ( "Nilai skewness dari data latih adalah: ", np.round ( Error_Test.skew ( ) , 2 ) )
# Kurtosis dari distribusi normal adalah 3
print ( "\nNilai kurtosis dari data latih adalah: ", np.round ( Error_Test.kurt ( ) + 3 , 2 )  )

Nilai skewness dari data latih adalah:  -0.67

Nilai kurtosis dari data latih adalah:  6.0

plt.figure ( figsize = ( 20 , 10 ) )
sns.regplot ( x = Y_Train_LR , y = Train_Y , color = '#62466B' , scatter_kws = { 's': 100 } , marker = '*' );
plt.xlabel ( "Predicted Values of Training Data" );
plt.ylabel ( "Actual values of Training Data" );
plt.title ( "Scatter plot for Homoscedasticity" );

plt.figure ( figsize = ( 20 , 10 ) )
sns.regplot ( x = Y_LR , y = Test_Y , color = '#62466B' , scatter_kws = { 's': 100 } , marker = '*' );
plt.xlabel ( "Predicted Values of Test Data" );
plt.ylabel ( "Actual values of Test Data" );
plt.title ( "Assumption Check : Linearity" );

Columns = list(Train_X.select_dtypes ( 'object' ).columns)
Step1 = ColumnTransformer(transformers=[('col_tnf', OneHotEncoder(drop='first'), Columns)], remainder='passthrough')
R = Ridge ( )
Parameters = { 'alpha' : [ 1.0 , 2.0 , 3.0 ] , 'max_iter' : [ 100 , 200 , 500 ] }
Step2 = GridSearchCV ( estimator = R , param_grid = Parameters , cv = 5 )
Pipeline_R = Pipeline ( [ ( 'step1' , Step1) , ( 'step2' , Step2 ) ] )
Pipeline_R.fit ( Train_X , Train_Y )
Parameters = Step2.best_params_
Step3 = Ridge ( **Parameters )
Pipeline_R = Pipeline ( [ ( 'step1' , Step1) , ( 'step3' , Step3 ) ] )
Pipeline_R.fit ( Train_X , Train_Y )

Pipeline(steps=[('step1',
                 ColumnTransformer(remainder='passthrough',
                                   transformers=[('col_tnf',
                                                  OneHotEncoder(drop='first'),
                                                  ['Company', 'TypeName',
                                                   'OpSys', 'CPU_Types',
                                                   'Memory_Types'])])),
                ('step3', Ridge(max_iter=100))])

Pipeline(steps=[('step1',
                 ColumnTransformer(remainder='passthrough',
                                   transformers=[('col_tnf',
                                                  OneHotEncoder(drop='first'),
                                                  ['Company', 'TypeName',
                                                   'OpSys', 'CPU_Types',
                                                   'Memory_Types'])])),
                ('step3', Ridge(max_iter=100))])

ColumnTransformer(remainder='passthrough',
                  transformers=[('col_tnf', OneHotEncoder(drop='first'),
                                 ['Company', 'TypeName', 'OpSys', 'CPU_Types',
                                  'Memory_Types'])])

['Company', 'TypeName', 'OpSys', 'CPU_Types', 'Memory_Types']

OneHotEncoder(drop='first')

['Ram', 'Weight', 'TouchScreen', 'PPI']

passthrough

Ridge(max_iter=100)

Y_R = Pipeline_R.predict ( Test_X )
R2_R = r2_score ( Test_Y , Y_R ) * 100
N = Train_X.shape[0] 
P = Train_X.shape[1]
print ( "Nilai R2 atau Koefisien Determinasi adalah: " , R2_R )
Adjusted_R2_R = 1 - ( ( 1 - R2_R ) * ( N - 1 ) / ( N - 1 - P ) )
MSE_R = mean_squared_error ( Test_Y , Y_R )
RMSE_R = np.sqrt ( MSE_R )
MAPE_R = mean_absolute_percentage_error ( Test_Y , Y_R ) * 100
MAE_R = mean_absolute_error ( Test_Y , Y_R )
print ( "\nNilai R² yang Disesuaikan adalah: " , Adjusted_R2_R )

Nilai R2 atau Koefisien Determinasi adalah:  72.45370969066059

Nilai R² yang Disesuaikan adalah:  73.1187390466233

R_PM = { 'Performance Metric' : [ 'R2' , 'Adjusted_R2' , 'MSE' , 'RMSE' , 'MAPE' , 'MAE' ] ,        
           'Values' : [ R2_R , Adjusted_R2_R , MSE_R , RMSE_R , MAPE_R , MAE_R ] }
R_Performance_Metrics = pd.DataFrame ( R_PM )
R_Performance_Metrics

plt.figure ( figsize = ( 20 , 10 ) )
sns.histplot ( ( Y_R - Test_Y ) , bins = 60 , color = '#840032' )
Y_Train_R = Pipeline_R.predict ( Train_X )
plt.figure ( figsize = ( 20 , 10 ) )
sns.histplot ( ( Y_Train_R - Train_Y ) , bins = 60 , color = '#6A8D92' );

Error_Train = Train_Y - Y_Train_R 
print ( "Nilai skewness dari data latih adalah: ", np.round ( Error_Train.skew ( ) , 2 ) )
print ( "\nNilai kurtosis dari data latih adalah: ", np.round ( Error_Train.kurt ( ) + 3 , 2 )  )

Nilai skewness dari data latih adalah:  0.17

Nilai kurtosis dari data latih adalah:  3.58

Error_Test = Test_Y - Y_R 
print ( "Nilai skewness dari data latih adalah: ", np.round ( Error_Test.skew ( ) , 2 ) )
print ( "\nNilai kurtosis dari data latih adalah: ", np.round ( Error_Test.kurt ( ) + 3 , 2 )  )

Nilai skewness dari data latih adalah:  -0.74

Nilai kurtosis dari data latih adalah:  6.4

plt.figure ( figsize = ( 20 , 10 ) )
sns.regplot ( x = Y_Train_R , y = Train_Y , color = '#1B2845' , scatter_kws = { 's': 100 } , marker = '*' );
plt.xlabel ( "Predicted Values of Training Data" );
plt.ylabel ( "Actual values of Training Data" );
plt.title ( "Scatter plot for Homoscedasticity" );

plt.figure ( figsize = ( 20 , 10 ) )
sns.regplot ( x = Y_R , y = Test_Y , color = '#62466B' , scatter_kws = { 's': 100 } , marker = '*' );
plt.xlabel ( "Predicted Values of Test Data" );
plt.ylabel ( "Actual values of Test Data" );
plt.title ( "Assumption Check : Linearity" );

Columns = list(Train_X.select_dtypes ( 'object' ).columns)
Step1 = ColumnTransformer(transformers=[('col_tnf', OneHotEncoder(drop='first'), Columns)], remainder='passthrough')
DT = DecisionTreeRegressor ( )
Parameters = { 'criterion' : [ "squared_error", "friedman_mse", "absolute_error", "poisson" ] ,
              'max_depth' : [ 10 , 15 , 20 ] , 'max_features' : [ "auto", "sqrt", "log2" ] }
Step2 = GridSearchCV ( estimator = DT , param_grid = Parameters , cv = 5 )
Pipeline_DT = Pipeline ( [ ( 'step1' , Step1) , ( 'step2' , Step2 ) ] )
Pipeline_DT.fit ( Train_X , Train_Y )
Parameters = Step2.best_params_
Step3 = DecisionTreeRegressor ( **Parameters )
Pipeline_DT = Pipeline ( [ ( 'step1' , Step1) , ( 'step3' , Step3 ) ] )
Pipeline_DT.fit ( Train_X , Train_Y )

Pipeline(steps=[('step1',
                 ColumnTransformer(remainder='passthrough',
                                   transformers=[('col_tnf',
                                                  OneHotEncoder(drop='first'),
                                                  ['Company', 'TypeName',
                                                   'OpSys', 'CPU_Types',
                                                   'Memory_Types'])])),
                ('step3',
                 DecisionTreeRegressor(max_depth=15, max_features='sqrt'))])

Pipeline(steps=[('step1',
                 ColumnTransformer(remainder='passthrough',
                                   transformers=[('col_tnf',
                                                  OneHotEncoder(drop='first'),
                                                  ['Company', 'TypeName',
                                                   'OpSys', 'CPU_Types',
                                                   'Memory_Types'])])),
                ('step3',
                 DecisionTreeRegressor(max_depth=15, max_features='sqrt'))])

ColumnTransformer(remainder='passthrough',
                  transformers=[('col_tnf', OneHotEncoder(drop='first'),
                                 ['Company', 'TypeName', 'OpSys', 'CPU_Types',
                                  'Memory_Types'])])

['Company', 'TypeName', 'OpSys', 'CPU_Types', 'Memory_Types']

OneHotEncoder(drop='first')

['Ram', 'Weight', 'TouchScreen', 'PPI']

passthrough

DecisionTreeRegressor(max_depth=15, max_features='sqrt')

Y_DT = Pipeline_DT.predict ( Test_X )
R2_DT = r2_score ( Test_Y , Y_DT ) * 100
N = Train_X.shape[0] 
P = Train_X.shape[1]
print ( "Nilai R2 atau Koefisien Determinasi adalah : " , R2_DT )
Adjusted_R2_DT = 1 - ( ( 1 - R2_DT ) * ( N - 1 ) / ( N - 1 - P ) )
MSE_DT = mean_squared_error ( Test_Y , Y_DT )
RMSE_DT = np.sqrt ( MSE_DT )
MAPE_DT = mean_absolute_percentage_error ( Test_Y , Y_DT ) * 100
MAE_DT = mean_absolute_error ( Test_Y , Y_DT )
print ( "\nNilai R² yang Disesuaikan adalah : " , Adjusted_R2_DT )

Nilai R2 atau Koefisien Determinasi adalah :  59.31822136274116

Nilai R² yang Disesuaikan adalah :  59.8609969493644

DT_PM = { 'Performance Metric' : [ 'R2' , 'Adjusted_R2' , 'MSE' , 'RMSE' , 'MAPE' , 'MAE' ] ,         
           'Values' : [ R2_DT , Adjusted_R2_DT , MSE_DT , RMSE_DT , MAPE_DT , MAE_DT ] }
DT_Performance_Metrics = pd.DataFrame ( DT_PM )
DT_Performance_Metrics

plt.figure ( figsize = ( 20 , 10 ) )
sns.histplot ( ( Y_DT - Test_Y ) , bins = 60 , color = '#8C271E' )
Y_Train_DT = Pipeline_DT.predict ( Train_X )
plt.figure ( figsize = ( 20 , 10 ) )
sns.histplot ( ( Y_Train_DT - Train_Y ) , bins = 60 , color = '#ABA194' );

Error_Train = Train_Y - Y_Train_DT
print ( "Nilai skewness dari data latih adalah : ", np.round ( Error_Train.skew ( ) , 2 ) )
print ( "\nNilai kurtosis dari data latih adalah : ", np.round ( Error_Train.kurt ( ) + 3 , 2 )  )

Nilai skewness dari data latih adalah :  0.8

Nilai kurtosis dari data latih adalah :  9.31

Error_Test = Test_Y - Y_DT 
print ( "Nilai skewness dari data latih adalah : ", np.round ( Error_Test.skew ( ) , 2 ) )
print ( "\nNilai kurtosis dari data latih adalah : ", np.round ( Error_Test.kurt ( ) + 3 , 2 )  )

Nilai skewness dari data latih adalah :  0.39

Nilai kurtosis dari data latih adalah :  7.42

plt.figure ( figsize = ( 20 , 10 ) )
sns.regplot ( x = Y_Train_DT , y = Train_Y , color = '#0F7173' , scatter_kws = { 's': 100 } , marker = '*' );
plt.xlabel ( "Predicted Values of Training Data" );
plt.ylabel ( "Actual values of Training Data" );
plt.title ( "Scatter plot for Homoscedasticity" );

plt.figure ( figsize = ( 20 , 10 ) )
sns.regplot ( x = Y_DT , y = Test_Y , color = '#993955' , scatter_kws = { 's': 100 } , marker = '*' );
plt.xlabel ( "Predicted Values of Test Data" );
plt.ylabel ( "Actual values of Test Data" );
plt.title ( "Assumption Check : Linearity" );

Columns = list(Train_X.select_dtypes('object').columns)
Step1 = ColumnTransformer(transformers=[('col_tnf', OneHotEncoder(drop='first'), Columns)], remainder='passthrough')
RF = RandomForestRegressor()
Parameters = {'n_estimators': [100, 200, 1000], 
              'max_depth': [10, 15, 20], 
              'criterion': ["squared_error", "absolute_error", "friedman_mse", "poisson"]}
Step2 = GridSearchCV(estimator=RF, param_grid=Parameters, cv=5)
Pipeline_RF = Pipeline([('step1', Step1), ('step2', Step2)])
Pipeline_RF.fit(Train_X, Train_Y)
Parameters = Step2.best_params_
Step3 = RandomForestRegressor(**Parameters)
Pipeline_RF = Pipeline([('step1', Step1), ('step3', Step3)])
Pipeline_RF.fit(Train_X, Train_Y)

Pipeline(steps=[('step1',
                 ColumnTransformer(remainder='passthrough',
                                   transformers=[('col_tnf',
                                                  OneHotEncoder(drop='first'),
                                                  ['Company', 'TypeName',
                                                   'OpSys', 'CPU_Types',
                                                   'Memory_Types'])])),
                ('step3',
                 RandomForestRegressor(criterion='absolute_error', max_depth=15,
                                       n_estimators=1000))])

Pipeline(steps=[('step1',
                 ColumnTransformer(remainder='passthrough',
                                   transformers=[('col_tnf',
                                                  OneHotEncoder(drop='first'),
                                                  ['Company', 'TypeName',
                                                   'OpSys', 'CPU_Types',
                                                   'Memory_Types'])])),
                ('step3',
                 RandomForestRegressor(criterion='absolute_error', max_depth=15,
                                       n_estimators=1000))])

ColumnTransformer(remainder='passthrough',
                  transformers=[('col_tnf', OneHotEncoder(drop='first'),
                                 ['Company', 'TypeName', 'OpSys', 'CPU_Types',
                                  'Memory_Types'])])

['Company', 'TypeName', 'OpSys', 'CPU_Types', 'Memory_Types']

OneHotEncoder(drop='first')

['Ram', 'Weight', 'TouchScreen', 'PPI']

passthrough

RandomForestRegressor(criterion='absolute_error', max_depth=15,
                      n_estimators=1000)

Y_RF = Pipeline_RF.predict ( Test_X )
R2_RF = r2_score ( Test_Y , Y_RF ) * 100
N = Train_X.shape[0] 
P = Train_X.shape[1]
print ( "Nilai R2 atau Koefisien Determinasi adalah : " , R2_RF )
Adjusted_R2_RF = 1 - ( ( 1 - R2_RF ) * ( N - 1 ) / ( N - 1 - P ) )
MSE_RF = mean_squared_error ( Test_Y , Y_RF )
RMSE_RF = np.sqrt ( MSE_RF )
MAPE_RF = mean_absolute_percentage_error ( Test_Y , Y_RF ) * 100
MAE_RF = mean_absolute_error ( Test_Y , Y_RF )
print ( "\nNilai R² yang Disesuaikan adalah : " , Adjusted_R2_RF )

Nilai R2 atau Koefisien Determinasi adalah :  81.7439773462029

Nilai R² yang Disesuaikan adalah :  82.4954724817932

RF_PM = { 'Performance Metric' : [ 'R2' , 'Adjusted_R2' , 'MSE' , 'RMSE' , 'MAPE' , 'MAE' ] ,         
           'Values' : [ R2_RF , Adjusted_R2_RF , MSE_RF , RMSE_RF , MAPE_RF , MAE_RF ] }
RF_Performance_Metrics = pd.DataFrame ( RF_PM )
RF_Performance_Metrics

plt.figure ( figsize = ( 20 , 10 ) )
sns.histplot ( ( Y_RF - Test_Y ) , bins = 60 , color = '#DD0426' )
Y_Train_RF = Pipeline_RF.predict ( Train_X )
plt.figure ( figsize = ( 20 , 10 ) )
sns.histplot ( ( Y_Train_RF - Train_Y ) , bins = 60 , color = '#273043' );

Error_Train = Train_Y - Y_Train_RF 
print ( "Nilai skewness dari data latih adalah : ", np.round ( Error_Train.skew ( ) , 2 ) )
print ( "\nNilai kurtosis dari data latih adalah : ", np.round ( Error_Train.kurt ( ) + 3 , 2 )  )

Nilai skewness dari data latih adalah :  0.18

Nilai kurtosis dari data latih adalah :  4.32

Error_Test = Test_Y - Y_RF 
print ( "Nilai skewness dari data latih adalah : ", np.round ( Error_Test.skew ( ) , 2 ) )
print ( "\nNilai kurtosis dari data latih adalah : ", np.round ( Error_Test.kurt ( ) + 3 , 2 )  )

Nilai skewness dari data latih adalah :  -0.15

Nilai kurtosis dari data latih adalah :  4.02

plt.figure ( figsize = ( 20 , 10 ) )
sns.regplot ( x = Y_Train_RF , y = Train_Y , color = '#56351E' , scatter_kws = { 's': 100 } , marker = '*' );
plt.xlabel ( "Predicted Values of Training Data" );
plt.ylabel ( "Actual values of Training Data" );
plt.title ( "Scatter plot for Homoscedasticity" );

plt.figure ( figsize = ( 20 , 10 ) )
sns.regplot ( x = Y_RF , y = Test_Y , color = '#946683' , scatter_kws = { 's': 100 } , marker = '*' );
plt.xlabel ( "Predicted Values of Test Data" );
plt.ylabel ( "Actual values of Test Data" );
plt.title ( "Assumption Check : Linearity" );

Columns = list(Train_X.select_dtypes('object').columns)
Step1 = ColumnTransformer(transformers=[('col_tnf', OneHotEncoder(drop='first'), Columns)], remainder='passthrough')
RF = RandomForestRegressor()
AB = AdaBoostRegressor()
Parameters = {'n_estimators': [50, 100, 200], 
              'learning_rate': [0.1, 0.01, 1], 'estimator': [RF]}
Step2 = GridSearchCV(estimator=AB, param_grid=Parameters, cv=5)
Pipeline_AB = Pipeline([('step1', Step1), ('step2', Step2)])
Pipeline_AB.fit(Train_X, Train_Y)
Parameters = Step2.best_params_
Step3 = AdaBoostRegressor(**Parameters)
Pipeline_AB = Pipeline([('step1', Step1), ('step3', Step3)])
Pipeline_AB.fit(Train_X, Train_Y)

Pipeline(steps=[('step1',
                 ColumnTransformer(remainder='passthrough',
                                   transformers=[('col_tnf',
                                                  OneHotEncoder(drop='first'),
                                                  ['Company', 'TypeName',
                                                   'OpSys', 'CPU_Types',
                                                   'Memory_Types'])])),
                ('step3',
                 AdaBoostRegressor(estimator=RandomForestRegressor(),
                                   learning_rate=0.1, n_estimators=200))])

Pipeline(steps=[('step1',
                 ColumnTransformer(remainder='passthrough',
                                   transformers=[('col_tnf',
                                                  OneHotEncoder(drop='first'),
                                                  ['Company', 'TypeName',
                                                   'OpSys', 'CPU_Types',
                                                   'Memory_Types'])])),
                ('step3',
                 AdaBoostRegressor(estimator=RandomForestRegressor(),
                                   learning_rate=0.1, n_estimators=200))])

ColumnTransformer(remainder='passthrough',
                  transformers=[('col_tnf', OneHotEncoder(drop='first'),
                                 ['Company', 'TypeName', 'OpSys', 'CPU_Types',
                                  'Memory_Types'])])

['Company', 'TypeName', 'OpSys', 'CPU_Types', 'Memory_Types']

OneHotEncoder(drop='first')

['Ram', 'Weight', 'TouchScreen', 'PPI']

passthrough

AdaBoostRegressor(estimator=RandomForestRegressor(), learning_rate=0.1,
                  n_estimators=200)

RandomForestRegressor()

RandomForestRegressor()

Y_AB = Pipeline_AB.predict ( Test_X )
R2_AB = r2_score ( Test_Y , Y_AB ) * 100
N = Train_X.shape[0] 
P = Train_X.shape[1]
print ( "Nilai R2 atau Koefisien Determinasi adalah : " , R2_AB )
Adjusted_R2_AB = 1 - ( ( 1 - R2_AB ) * ( N - 1 ) / ( N - 1 - P ) )
MSE_AB = mean_squared_error ( Test_Y , Y_AB )
RMSE_AB = np.sqrt ( MSE_AB )
MAPE_AB = mean_absolute_percentage_error ( Test_Y , Y_AB ) * 100
MAE_AB = mean_absolute_error ( Test_Y , Y_AB )
print ( "\nNilai R2 yang Disesuaikan adalah: " , Adjusted_R2_AB )

Nilai R2 atau Koefisien Determinasi adalah :  81.64888385263917

Nilai R2 yang Disesuaikan adalah:  82.3994939402025

AB_PM = { 'Performance Metric' : [ 'R2' , 'Adjusted_R2' , 'MSE' , 'RMSE' , 'MAPE' , 'MAE' ] ,         
           'Values' : [ R2_AB , Adjusted_R2_AB , MSE_AB , RMSE_AB , MAPE_AB , MAE_AB ] }
AB_Performance_Metrics = pd.DataFrame ( AB_PM )
AB_Performance_Metrics

plt.figure ( figsize = ( 20 , 10 ) )
sns.histplot ( ( Y_AB - Test_Y ) , bins = 60 , color = '#1E1014' )
Y_Train_AB = Pipeline_AB.predict ( Train_X )
plt.figure ( figsize = ( 20 , 10 ) )
sns.histplot ( ( Y_Train_AB - Train_Y ) , bins = 60 , color = '#114B5F' );

Error_Train = Train_Y - Y_Train_AB
print ( "Nilai skewness dari data latih adalah : ", np.round ( Error_Train.skew ( ) , 2 ) )
print ( "\nNilai kurtosis dari data latih adalah : ", np.round ( Error_Train.kurt ( ) + 3 , 2 )  )

Nilai skewness dari data latih adalah :  0.02

Nilai kurtosis dari data latih adalah :  2.96

Error_Test = Test_Y - Y_AB
print ( "Nilai skewness dari data latih adalah : ", np.round ( Error_Test.skew ( ) , 2 ) )
print ( "\nNilai kurtosis dari data latih adalah : ", np.round ( Error_Test.kurt ( ) + 3 , 2 )  )

Nilai skewness dari data latih adalah :  -0.17

Nilai kurtosis dari data latih adalah :  4.11

plt.figure ( figsize = ( 20 , 10 ) )
sns.regplot ( x = Y_Train_AB , y = Train_Y , color = '#472D30' , scatter_kws = { 's': 100 } , marker = '*' );
plt.xlabel ( "Predicted Values of Training Data" );
plt.ylabel ( "Actual values of Training Data" );
plt.title ( "Scatter plot for Homoscedasticity" );

plt.figure ( figsize = ( 20 , 10 ) )
sns.regplot ( x = Y_AB , y = Test_Y , color = '#481D24' , scatter_kws = { 's': 100 } , marker = '*' );
plt.xlabel ( "Predicted Values of Test Data" );
plt.ylabel ( "Actual values of Test Data" );
plt.title ( "Assumption Check : Linearity" );

GB = GradientBoostingRegressor ( )
Parameters = { 'n_estimators' : [ 50 , 100 , 200 ] , 'learning_rate' : [ 0.1 , 0.01, 1 ] , 
              'loss' : [ 'squared_error', 'absolute_error', 'huber', 'quantile' ] }
Step2 = GridSearchCV ( estimator = GB , param_grid = Parameters , cv = 5 )
Pipeline_GB = Pipeline ( [ ( 'step1' , Step1) , ( 'step2' , Step2 ) ] )
Pipeline_GB.fit ( Train_X , Train_Y )
Parameters = Step2.best_params_
Step3 = GradientBoostingRegressor ( **Parameters )
Pipeline_GB = Pipeline ( [ ( 'step1' , Step1) , ( 'step3' , Step3 ) ] )
Pipeline_GB.fit ( Train_X , Train_Y )

Pipeline(steps=[('step1',
                 ColumnTransformer(remainder='passthrough',
                                   transformers=[('col_tnf',
                                                  OneHotEncoder(drop='first'),
                                                  ['Company', 'TypeName',
                                                   'OpSys', 'CPU_Types',
                                                   'Memory_Types'])])),
                ('step3', GradientBoostingRegressor(n_estimators=200))])

Pipeline(steps=[('step1',
                 ColumnTransformer(remainder='passthrough',
                                   transformers=[('col_tnf',
                                                  OneHotEncoder(drop='first'),
                                                  ['Company', 'TypeName',
                                                   'OpSys', 'CPU_Types',
                                                   'Memory_Types'])])),
                ('step3', GradientBoostingRegressor(n_estimators=200))])

ColumnTransformer(remainder='passthrough',
                  transformers=[('col_tnf', OneHotEncoder(drop='first'),
                                 ['Company', 'TypeName', 'OpSys', 'CPU_Types',
                                  'Memory_Types'])])

['Company', 'TypeName', 'OpSys', 'CPU_Types', 'Memory_Types']

OneHotEncoder(drop='first')

['Ram', 'Weight', 'TouchScreen', 'PPI']

passthrough

GradientBoostingRegressor(n_estimators=200)

Y_GB = Pipeline_GB.predict ( Test_X )
R2_GB = r2_score ( Test_Y , Y_GB ) * 100
print ( "Nilai R² atau Koefisien Determinasi adalah : " , R2_GB )
Adjusted_R2_GB = 1 - ( ( 1 - R2_GB ) * ( N - 1 ) / ( N - 1 - P ) )
MSE_GB = mean_squared_error ( Test_Y , Y_GB )
RMSE_GB = np.sqrt ( MSE_GB )
MAPE_GB = mean_absolute_percentage_error ( Test_Y , Y_GB ) * 100
MAE_GB = mean_absolute_error ( Test_Y , Y_GB )
print ( "\nNilai R² yang Disesuaikan adalah : " , Adjusted_R2_GB )

Nilai R² atau Koefisien Determinasi adalah :  81.85565899931217

Nilai R² yang Disesuaikan adalah :  82.60819357117754

GB_PM = { 'Performance Metric' : [ 'R2' , 'Adjusted_R2' , 'MSE' , 'RMSE' , 'MAPE' , 'MAE' ] ,         
           'Values' : [ R2_GB , Adjusted_R2_GB , MSE_GB , RMSE_GB , MAPE_GB , MAE_GB ] }
GB_Performance_Metrics = pd.DataFrame ( GB_PM )
GB_Performance_Metrics

plt.figure ( figsize = ( 20 , 10 ) )
sns.histplot ( ( Y_GB - Test_Y ) , bins = 60 , color = '#1C0B19' )
Y_Train_GB = Pipeline_GB.predict ( Train_X )
plt.figure ( figsize = ( 20 , 10 ) )
sns.histplot ( ( Y_Train_GB - Train_Y ) , bins = 60 , color = '#13303D' );

Error_Train = Train_Y - Y_Train_GB
print ( "Nilai skewness dari data latih adalah : ", np.round ( Error_Train.skew ( ) , 2 ) )
print ( "\nNilai kurtosis dari data latih adalah : ", np.round ( Error_Train.kurt ( ) + 3 , 2 )  )

Nilai skewness dari data latih adalah :  0.16

Nilai kurtosis dari data latih adalah :  3.72

Error_Test = Test_Y - Y_GB
print ( "Nilai skewness dari data latih adalah : ", np.round ( Error_Test.skew ( ) , 2 ) )
print ( "\nNilai kurtosis dari data latih adalah : ", np.round ( Error_Test.kurt ( ) + 3 , 2 )  )

Nilai skewness dari data latih adalah :  -0.05

Nilai kurtosis dari data latih adalah :  3.89

plt.figure ( figsize = ( 20 , 10 ) )
sns.regplot ( x = Y_Train_GB , y = Train_Y , color = '#9F4A54' , scatter_kws = { 's': 100 } , marker = '*' );
plt.xlabel ( "Predicted Values of Training Data" );
plt.ylabel ( "Actual values of Training Data" );
plt.title ( "Scatter plot for Homoscedasticity" );

plt.figure ( figsize = ( 20 , 10 ) )
sns.regplot ( x = Y_GB , y = Test_Y , color = '#481D24' , scatter_kws = { 's': 100 } , marker = '*' );
plt.xlabel ( "Predicted Values of Test Data" );
plt.ylabel ( "Actual values of Test Data" );
plt.title ( "Assumption Check : Linearity" );

XGB = XGBRFRegressor ( )
Parameters = { 'learning_rate' : [ 0.1 , 0.01, 1 ] , 'max_depth' : [ 10 , 15 , 20 ] }
Step2 = GridSearchCV ( estimator = XGB , param_grid = Parameters , cv = 5 )
Pipeline_XGB = Pipeline ( [ ( 'step1' , Step1) , ( 'step2' , Step2 ) ] )
Pipeline_XGB.fit ( Train_X , Train_Y )
Parameters = Step2.best_params_
Step3 = XGBRFRegressor ( **Parameters )
Pipeline_XGB = Pipeline ( [ ( 'step1' , Step1) , ( 'step3' , Step3 ) ] )
Pipeline_XGB.fit ( Train_X , Train_Y )

Pipeline(steps=[('step1',
                 ColumnTransformer(remainder='passthrough',
                                   transformers=[('col_tnf',
                                                  OneHotEncoder(drop='first'),
                                                  ['Company', 'TypeName',
                                                   'OpSys', 'CPU_Types',
                                                   'Memory_Types'])])),
                ('step3',
                 XGBRFRegressor(base_score=None, booster=None, callbacks=None,
                                colsample_bylevel=None, colsample_bytree=None,
                                device=None, early_stopping_rounds=None,
                                enable_categoric...
                                grow_policy=None, importance_type=None,
                                interaction_constraints=None, learning_rate=1,
                                max_bin=None, max_cat_threshold=None,
                                max_cat_to_onehot=None, max_delta_step=None,
                                max_depth=10, max_leaves=None,
                                min_child_weight=None, missing=nan,
                                monotone_constraints=None, multi_strategy=None,
                                n_estimators=None, n_jobs=None,
                                num_parallel_tree=None,
                                objective='reg:squarederror', random_state=None, ...))])

Pipeline(steps=[('step1',
                 ColumnTransformer(remainder='passthrough',
                                   transformers=[('col_tnf',
                                                  OneHotEncoder(drop='first'),
                                                  ['Company', 'TypeName',
                                                   'OpSys', 'CPU_Types',
                                                   'Memory_Types'])])),
                ('step3',
                 XGBRFRegressor(base_score=None, booster=None, callbacks=None,
                                colsample_bylevel=None, colsample_bytree=None,
                                device=None, early_stopping_rounds=None,
                                enable_categoric...
                                grow_policy=None, importance_type=None,
                                interaction_constraints=None, learning_rate=1,
                                max_bin=None, max_cat_threshold=None,
                                max_cat_to_onehot=None, max_delta_step=None,
                                max_depth=10, max_leaves=None,
                                min_child_weight=None, missing=nan,
                                monotone_constraints=None, multi_strategy=None,
                                n_estimators=None, n_jobs=None,
                                num_parallel_tree=None,
                                objective='reg:squarederror', random_state=None, ...))])

ColumnTransformer(remainder='passthrough',
                  transformers=[('col_tnf', OneHotEncoder(drop='first'),
                                 ['Company', 'TypeName', 'OpSys', 'CPU_Types',
                                  'Memory_Types'])])

['Company', 'TypeName', 'OpSys', 'CPU_Types', 'Memory_Types']

OneHotEncoder(drop='first')

['Ram', 'Weight', 'TouchScreen', 'PPI']

passthrough

XGBRFRegressor(base_score=None, booster=None, callbacks=None,
               colsample_bylevel=None, colsample_bytree=None, device=None,
               early_stopping_rounds=None, enable_categorical=False,
               eval_metric=None, feature_types=None, gamma=None,
               grow_policy=None, importance_type=None,
               interaction_constraints=None, learning_rate=1, max_bin=None,
               max_cat_threshold=None, max_cat_to_onehot=None,
               max_delta_step=None, max_depth=10, max_leaves=None,
               min_child_weight=None, missing=nan, monotone_constraints=None,
               multi_strategy=None, n_estimators=None, n_jobs=None,
               num_parallel_tree=None, objective='reg:squarederror',
               random_state=None, ...)

Y_XGB = Pipeline_XGB.predict ( Test_X )
R2_XGB = r2_score ( Test_Y , Y_XGB ) * 100
print ( "Nilai R² atau Koefisien Determinasi adalah : " , R2_XGB )
Adjusted_R2_XGB = 1 - ( ( 1 - R2_XGB ) * ( N - 1 ) / ( N - 1 - P ) )
MSE_XGB = mean_squared_error ( Test_Y , Y_XGB )
RMSE_XGB = np.sqrt ( MSE_XGB )
MAPE_XGB = mean_absolute_percentage_error ( Test_Y , Y_XGB ) * 100
MAE_XGB = mean_absolute_error ( Test_Y , Y_XGB )
print ( "\nNilai R² yang Disesuaikan adalah : " , Adjusted_R2_XGB )

Nilai R² atau Koefisien Determinasi adalah :  78.35340515851038

Nilai R² yang Disesuaikan adalah :  79.07334377942723

XGB_PM = { 'Performance Metric' : [ 'R2' , 'Adjusted_R2' , 'MSE' , 'RMSE' , 'MAPE' , 'MAE' ] ,   
           'Values' : [ R2_XGB , Adjusted_R2_XGB , MSE_XGB , RMSE_XGB , MAPE_XGB , MAE_XGB ] }
XGB_Performance_Metrics = pd.DataFrame ( XGB_PM )
XGB_Performance_Metrics

plt.figure ( figsize = ( 20 , 10 ) )
sns.histplot ( ( Y_XGB - Test_Y ) , bins = 60 , color = '#773344' )
Y_Train_XGB = Pipeline_XGB.predict ( Train_X )
plt.figure ( figsize = ( 20 , 10 ) )
sns.histplot ( ( Y_Train_XGB - Train_Y ) , bins = 60 , color = '#8DA7BE' );

Error_Train = Train_Y - Y_Train_XGB
print ( "Nilai skewness dari data latih adalah : ", np.round ( Error_Train.skew ( ) , 2 ) )
print ( "\nNilai kurtosis dari data latih adalah : ", np.round ( Error_Train.kurt ( ) + 3 , 2 )  )

Nilai skewness dari data latih adalah :  0.06

Nilai kurtosis dari data latih adalah :  4.03

Error_Test = Test_Y - Y_XGB
print ( "Nilai skewness dari data latih adalah : ", np.round ( Error_Test.skew ( ) , 2 ) )
print ( "\nNilai kurtosis dari data latih adalah : ", np.round ( Error_Test.kurt ( ) + 3 , 2 )  )

Nilai skewness dari data latih adalah :  -0.27

Nilai kurtosis dari data latih adalah :  4.38

plt.figure ( figsize = ( 20 , 10 ) )
sns.regplot ( x = Y_Train_XGB , y = Train_Y , color = '#4C2C69' , scatter_kws = { 's': 100 } , marker = '*' );
plt.xlabel ( "Predicted Values of Training Data" );
plt.ylabel ( "Actual values of Training Data" );
plt.title ( "Scatter plot for Homoscedasticity" );

plt.figure ( figsize = ( 20 , 10 ) )
sns.regplot ( x = Y_XGB , y = Test_Y , color = '#011936' , scatter_kws = { 's': 100 } , marker = '*' );
plt.xlabel ( "Predicted Values of Test Data" );
plt.ylabel ( "Actual values of Test Data" );
plt.title ( "Assumption Check : Linearity" );

ax = plt.gca ( )
for i in [ LR_Performance_Metrics , DT_Performance_Metrics , RF_Performance_Metrics , AB_Performance_Metrics , GB_Performance_Metrics , XGB_Performance_Metrics ]:
    sns.lineplot ( x = 'Performance Metric'  , y =  'Values' , data = i , palette = 'twilight' , markers = '*' , ax = ax );
ax.legend ( [ 'Linear Regression' , 'Decision Tree' , 'Random Forest' , 'AdaBoost Regressor ( RF )' , 'Gradient Boosting Regressor' , 'Extreme Gradient Boosting Regressor' ] );

R2 = [ R2_LR , R2_R , R2_DT , R2_RF , R2_AB , R2_GB , R2_XGB ]
R2 = pd.DataFrame ( { 'R2_Names' : [ 'R2_LR' , 'R2_R' , 'R2_DT' , 'R2_RF' , 'R2_AB' , 'R2_GB' , 'R2_XGB' ] , 'R2_values' : R2 } )
R2.sort_values ( by = 'R2_values' , ascending = False )

	Unnamed: 0	Company	TypeName	Inches	ScreenResolution	Cpu	Ram	Memory	Gpu	OpSys	Weight	Price
0	0	Apple	Ultrabook	13.3	IPS Panel Retina Display 2560x1600	Intel Core i5 2.3GHz	8GB	128GB SSD	Intel Iris Plus Graphics 640	macOS	1.37kg	71378.6832
1	1	Apple	Ultrabook	13.3	1440x900	Intel Core i5 1.8GHz	8GB	128GB Flash Storage	Intel HD Graphics 6000	macOS	1.34kg	47895.5232
2	2	HP	Notebook	15.6	Full HD 1920x1080	Intel Core i5 7200U 2.5GHz	8GB	256GB SSD	Intel HD Graphics 620	No OS	1.86kg	30636.0000
3	3	Apple	Ultrabook	15.4	IPS Panel Retina Display 2880x1800	Intel Core i7 2.7GHz	16GB	512GB SSD	AMD Radeon Pro 455	macOS	1.83kg	135195.3360
4	4	Apple	Ultrabook	13.3	IPS Panel Retina Display 2560x1600	Intel Core i5 3.1GHz	8GB	256GB SSD	Intel Iris Plus Graphics 650	macOS	1.37kg	96095.8080
...	...	...	...	...	...	...	...	...	...	...	...	...
1298	1298	Lenovo	2 in 1 Convertible	14.0	IPS Panel Full HD / Touchscreen 1920x1080	Intel Core i7 6500U 2.5GHz	4GB	128GB SSD	Intel HD Graphics 520	Windows 10	1.8kg	33992.6400
1299	1299	Lenovo	2 in 1 Convertible	13.3	IPS Panel Quad HD+ / Touchscreen 3200x1800	Intel Core i7 6500U 2.5GHz	16GB	512GB SSD	Intel HD Graphics 520	Windows 10	1.3kg	79866.7200
1300	1300	Lenovo	Notebook	14.0	1366x768	Intel Celeron Dual Core N3050 1.6GHz	2GB	64GB Flash Storage	Intel HD Graphics	Windows 10	1.5kg	12201.1200
1301	1301	HP	Notebook	15.6	1366x768	Intel Core i7 6500U 2.5GHz	6GB	1TB HDD	AMD Radeon R5 M330	Windows 10	2.19kg	40705.9200
1302	1302	Asus	Notebook	15.6	1366x768	Intel Celeron Dual Core N3050 1.6GHz	4GB	500GB HDD	Intel HD Graphics	Windows 10	2.2kg	19660.3200

	Unnamed: 0	Inches	Price
count	1303.00000	1303.000000	1303.000000
mean	651.00000	15.017191	59870.042910
std	376.28801	1.426304	37243.201786
min	0.00000	10.100000	9270.720000
25%	325.50000	14.000000	31914.720000
50%	651.00000	15.600000	52054.560000
75%	976.50000	15.600000	79274.246400
max	1302.00000	18.400000	324954.720000

	Company	TypeName	Inches	ScreenResolution	Cpu	Ram	Memory	Gpu	OpSys	Weight	Price
0	Apple	Ultrabook	13.3	IPS Panel Retina Display 2560x1600	Intel Core i5 2.3GHz	8GB	128GB SSD	Intel Iris Plus Graphics 640	macOS	1.37kg	71378.6832
1	Apple	Ultrabook	13.3	1440x900	Intel Core i5 1.8GHz	8GB	128GB Flash Storage	Intel HD Graphics 6000	macOS	1.34kg	47895.5232
2	HP	Notebook	15.6	Full HD 1920x1080	Intel Core i5 7200U 2.5GHz	8GB	256GB SSD	Intel HD Graphics 620	No OS	1.86kg	30636.0000
3	Apple	Ultrabook	15.4	IPS Panel Retina Display 2880x1800	Intel Core i7 2.7GHz	16GB	512GB SSD	AMD Radeon Pro 455	macOS	1.83kg	135195.3360
4	Apple	Ultrabook	13.3	IPS Panel Retina Display 2560x1600	Intel Core i5 3.1GHz	8GB	256GB SSD	Intel Iris Plus Graphics 650	macOS	1.37kg	96095.8080
...	...	...	...	...	...	...	...	...	...	...	...
1298	Lenovo	2 in 1 Convertible	14.0	IPS Panel Full HD / Touchscreen 1920x1080	Intel Core i7 6500U 2.5GHz	4GB	128GB SSD	Intel HD Graphics 520	Windows 10	1.8kg	33992.6400
1299	Lenovo	2 in 1 Convertible	13.3	IPS Panel Quad HD+ / Touchscreen 3200x1800	Intel Core i7 6500U 2.5GHz	16GB	512GB SSD	Intel HD Graphics 520	Windows 10	1.3kg	79866.7200
1300	Lenovo	Notebook	14.0	1366x768	Intel Celeron Dual Core N3050 1.6GHz	2GB	64GB Flash Storage	Intel HD Graphics	Windows 10	1.5kg	12201.1200
1301	HP	Notebook	15.6	1366x768	Intel Core i7 6500U 2.5GHz	6GB	1TB HDD	AMD Radeon R5 M330	Windows 10	2.19kg	40705.9200
1302	Asus	Notebook	15.6	1366x768	Intel Celeron Dual Core N3050 1.6GHz	4GB	500GB HDD	Intel HD Graphics	Windows 10	2.2kg	19660.3200

	Company	TypeName	ScreenResolution	Cpu	Ram	Memory	Gpu	OpSys	Weight
count	1303	1303	1303	1303	1303	1303	1303	1303	1303
unique	19	6	40	118	9	39	110	9	179
top	Dell	Notebook	Full HD 1920x1080	Intel Core i5 7200U 2.5GHz	8GB	256GB SSD	Intel HD Graphics 620	Windows 10	2.2kg
freq	297	727	507	190	619	412	281	1072	121

	Performance Metric	Values
0	R2	73.089266
1	Adjusted_R2	73.760210
2	MSE	0.095278
3	RMSE	0.308672
4	MAPE	2.198295
5	MAE	0.238868

	Performance Metric	Values
0	R2	72.453710
1	Adjusted_R2	73.118739
2	MSE	0.097529
3	RMSE	0.312296
4	MAPE	2.214893
5	MAE	0.240673

	Performance Metric	Values
0	R2	59.318221
1	Adjusted_R2	59.860997
2	MSE	0.144035
3	RMSE	0.379520
4	MAPE	2.451663
5	MAE	0.265139

	Performance Metric	Values
0	R2	81.743977
1	Adjusted_R2	82.495472
2	MSE	0.064636
3	RMSE	0.254236
4	MAPE	1.810082
5	MAE	0.195169

	Performance Metric	Values
0	R2	81.648884
1	Adjusted_R2	82.399494
2	MSE	0.064973
3	RMSE	0.254898
4	MAPE	1.833566
5	MAE	0.197642

	Performance Metric	Values
0	R2	81.855659
1	Adjusted_R2	82.608194
2	MSE	0.064241
3	RMSE	0.253457
4	MAPE	1.796782
5	MAE	0.194063

	Performance Metric	Values
0	R2	78.353405
1	Adjusted_R2	79.073344
2	MSE	0.076641
3	RMSE	0.276840
4	MAPE	1.966545
5	MAE	0.211812

	R2_Names	R2_values
5	R2_GB	81.855659
3	R2_RF	81.743977
4	R2_AB	81.648884
6	R2_XGB	78.353405
0	R2_LR	73.089266
1	R2_R	72.453710
2	R2_DT	59.318221

PREDIKSI HARGA LAPTOP DENGAN METODE SUPERVISED LEARNING REGRESSION¶

DISCLAIMER¶

Ringkasan Projek¶

Permasalahan¶

Tujuan & Model Alur Penyelesaian¶

IMPORTING LIBRARIES¶

IMPORTING DATA¶

STATISTICAL ANALYSIS¶

STATISTICAL SUMMARY¶

DROPPING THE UNIQUE COLUMN¶

(EDA)EXPLORATORY DATA ANALYSIS¶

EXTRACTING COLUMNS¶

DATA VISUALIZATION¶

BASIC LINE PLOTS¶

OPERATING SYSTEM AND SIZE DISTRIBUTION¶

PRICE DISTRIBUTION¶

RAM DISTRIBUTION¶

TOUCHSCREEN¶

SIZE DISTRIBUTION WRT CPU TYPES¶

OUTLIERS¶

DETECTING OUTLIERS¶

TREATING OUTLIERS¶

DATA CLEANING¶

NULL VALUES¶

CATEGORICAL COLUMNS¶

CORRELATION¶

DATA PREPROCESSING¶

PREDICTIVE MODELING¶

LINEAR REGRESSION¶

PREDICTION & PERFORMANCE EVALUATION¶

CHECKING FOR ASSUMPTIONS¶

NORMAL DISTRIBUTION¶

HOMOSCEDASTICITY¶

LINEARITY¶

RIDGE REGRESSION¶

CHECKING FOR ASSUMPTIONS¶

NORMALITY¶

HOMOSCEDASTICITY¶

LINEARITY¶

DECISION TREE REGRESSION¶

CHECKING FOR ASSUMPTIONS¶

NORMALITY¶

HOMOSCEDASTICITY¶

LINEARITY¶

RANDOM FOREST REGRESSION¶

CHECKING FOR ASSUMPTIONS¶

NORMALITY¶

HOMOSCEDASTICITY¶

LINEARITY¶

ADABOOST REGRESSOR¶

CHECKING FOR ASSUMPTIONS¶

NORMALITY¶

HOMOSCEDASTICITY¶

LINEARITY¶

GRADIENT BOOSTING¶

CHECKING FOR ASSUMPTIONS¶

NORMALITY¶

HOMOSCEDASTICITY¶

LINEARITY¶

EXTREME GRADIENT BOOSTING¶

CHECKING FOR ASSUMPTIONS¶

NORMALITY¶

HOMOSCEDASTICITY¶

LINEARITY¶

Diskusi Hasil Dan Kesimpulan¶

GRAPHICAL COMPARISON¶

COMPARISON OF R2¶

BEST MODEL¶

PENGUJIAN¶